home *** CD-ROM | disk | FTP | other *** search
/ Gold Medal Software 3 / Gold Medal Software - Volume 3 (Gold Medal) (1994).iso / graphics / 3dvect30.arj / 3D2.ASM < prev    next >
Assembly Source File  |  1993-11-18  |  24KB  |  817 lines
  1. ;3d vector routines full sorting method (slower)
  2. ;
  3. ; - objects can pass through one another and still be sorted correctly
  4. ; - maxsurfs and maxpoints must be large - set to TOTAL points/surfs on screen
  5. ;
  6. ; to use:
  7. ;
  8. ;          call look_at_it         ; make camera look at selected object
  9. ;          call setsincose         ; set rotation multipliers for eye
  10. ;          call show_stars         ; plot background stars
  11. ;          call makeobjs           ; plot all objects in sides table
  12. ;          call instant_mouse      ; plot mouse on screen
  13. ;          call flip_page          ; flip video pages
  14. ;          call clear_fill         ; clear video memory (last screen)
  15. ;          call resetupd           ; reset update for borders
  16. ;          call updvectors         ; move objects around, rotate them
  17.  
  18.            .386p
  19.            jumps
  20.  
  21. code32     segment para public use32
  22.            assume cs:code32, ds:code32
  23.  
  24. ; define externals
  25.  
  26.            extrn objbase:dword     ; object lists and bitmap lists are
  27.            extrn bitbase:dword     ; external! set to 0 if none
  28.            extrn bitx:dword        ; x and y sizes for 3d conversion
  29.            extrn bity:dword
  30.  
  31.            include pmode.inc       ; protected mode externals
  32.            include xmouse.inc      ; xmode mouse externals
  33.            include xmode.inc       ; xmode externals by matt pritchard
  34.            include irq.inc
  35.            include font.inc
  36.  
  37.            include macros.inc
  38.            include equ.inc
  39.  
  40.            include vars2.inc       ; labels and such
  41.            align 16
  42.            include arctan.inc      ; inverse tan
  43.            include sin.inc         ; sin/cosin table
  44.            include shading.inc     ; arctan shading tables
  45.            include math.inc        ; rotate, cos,sin,arctan...
  46.            include xscale.inc
  47.            include poly.inc        ; common ploygon stuff
  48.  
  49.            public makeobjs
  50.            public make1obj
  51.            public flush_surfaces
  52.            public init_tables
  53.  
  54.            strip_bytes equ 4
  55.  
  56.            align 16
  57.  
  58. abort_all:
  59.            add esp,strip_bytes    ; abort from loadpoints and make1obj
  60.            ret                    ; returning now from makeobjs call
  61.  
  62.            align 16
  63.  
  64. loadpoints:
  65.            mov bl,userotate[esi]
  66.  
  67.            mov si,whatshape[esi*2] ; get shape, bp = z distance
  68.            mov esi,objbase[esi*4]
  69.            sub esi,4
  70.  
  71. view_is_not_ok:
  72.            add esi,4
  73.            lodsd
  74.  
  75.            cmp eax,zad            ; check if too far to see detail anyway
  76.            jb s view_is_not_ok
  77.  
  78.            lodsd
  79.            add esi,eax
  80. llkk:
  81.            mov ax,[esi]
  82.            mov numpoints,ax
  83.  
  84.            movzx edi,pointindex   ; set xp,yp,zp pointer
  85.  
  86.            add ax,1               ; compensate for center of gravity point
  87.  
  88.            shl ax,1
  89.            add ax,pointindex      ; pointindex = word indexer to last point
  90.            cmp ax,maxpoints*2     ; test for overflow in points tables
  91.            jae abort_all
  92.  
  93.            mov ax,[esi+2]
  94.            mov numsides,ax
  95.  
  96.            add ax,showing
  97.            cmp ax,maxsurfaces-1   ; check for overflow in "sides" tables
  98.            jae abort_all
  99.  
  100.            add esi,4+50           ; skip point and side totals, skip future data
  101.            mov lindex,di          ; set last index to points (this one)
  102.  
  103.            add di,2               ; compensate for center of gravity point
  104. middle_load_points:
  105.            or  bl,bl              ; check userotate command
  106.            jne s np13             ; use different loop if no rotation
  107. np12:
  108.            mov bx,[esi]           ; x
  109.            mov cx,[esi+2]         ; y
  110.            mov bp,[esi+4]         ; z
  111.  
  112.            push edi esi
  113.            call rotate            ; rotate based on object matrix
  114.            add ebp,zad
  115.  
  116.            cmp ebp,ztruncate
  117.            jge s ntrunct
  118.            neg ebp
  119.            cmp ebp,ztruncate
  120.            jge s ntrunct
  121.            mov ebp,ztruncate
  122. ntrunct:
  123.            add ebx,xad
  124.            add ecx,yad
  125.            call make3d
  126.            pop esi edi
  127.            mov xp[edi],bx
  128.            mov yp[edi],cx
  129.            mov zp[edi],bp
  130.            add di,2               ; inc xp indexer
  131.            add esi,6              ; inc input pointer
  132.            dec numpoints
  133.            jne s np12
  134.  
  135.            mov pointindex,di      ; save for next call of loadpoints
  136.  
  137.            ret                    ; esi exits with pointer to sides
  138. np13:
  139.            mov bx,[esi]           ; x
  140.            mov cx,[esi+2]         ; y
  141.            mov bp,[esi+4]         ; z
  142.  
  143.            push edi esi
  144.  
  145.            call rotatenull        ; rotation matrix already set up! (camera)
  146.  
  147.            add ebp,zad
  148.  
  149.            cmp ebp,ztruncate
  150.            jge s ntrunct2
  151.            neg ebp
  152.            cmp ebp,ztruncate
  153.            jge s ntrunct
  154.            mov ebp,ztruncate
  155. ntrunct2:
  156.            add ebx,xad
  157.            add ecx,yad
  158.            call make3d
  159.            pop esi edi
  160.            mov xp[edi],bx
  161.            mov yp[edi],cx
  162.            mov zp[edi],bp
  163.            add di,2               ; inc xp indexer
  164.            add esi,6
  165.            dec numpoints
  166.            jne s np13
  167.  
  168.            mov pointindex,di      ; save for next call of loadpoints
  169.  
  170.            ret
  171.  
  172.            align 16
  173.  
  174. ; handle loading of bitmap from object list
  175.  
  176. ; eg   dw 32,8,5,50,60 ;command is 32,point 8, bitmap 5, x&y scaling of 50,60
  177.  
  178. ld_special:
  179.            lodsw                  ; get from si, first is point
  180.            shl ax,1
  181.            add ax,lindex          ; add to include offset in list
  182.            stosw                  ; put in sides table
  183.  
  184.            mov dx,bp              ; save indexer
  185.            movzx ebp,ax           ; get point indexers
  186.            mov ax,zp[ebp]
  187.            mov zeds[ebx],ax       ; set zed for sort.
  188.            mov bp,dx
  189.  
  190.            movsw                  ; get bitmap type
  191.            movsw                  ; get x then y scaling
  192.            movsw
  193.  
  194.            mov dx,command         ; get command (for iteration bits)
  195.            mov textures[ebx],dx
  196.  
  197.            cmp zad,64000          ; bitmaps farther than 65536 screw up
  198.            jge no_norml           ; you can't see them anyway. prevent overflow
  199.            jmp ln3
  200.  
  201.            align 16
  202.  
  203. loadsides:
  204.            mov edi,offsides       ; get ready for lodsw and stosw
  205.            mov ebp,edi            ; ebp = offset to first point in side
  206.            movzx ebx,showing      ; bx = word indexer for surfaces
  207.            shl bx,1
  208. ld_lp:
  209.            lodsw                  ; get command word
  210.            mov command,ax
  211.  
  212.            test ax,himap          ; if bitmap, do special load,
  213.            jnz ld_special         ; or test previous color
  214.  
  215.            lodsd                  ; get texture data/type
  216.            mov texture12,eax
  217.  
  218.            lodsd                  ; get colour, high byte is other side
  219.            mov colors12,eax
  220.  
  221.            mov cx,lindex          ; quick add for loop
  222.  
  223.            lodsw                  ; get from si, first is unconditinal
  224.            shl ax,1
  225.            add ax,cx              ; add to include offset in list
  226.            stosw                  ; put in di
  227.            mov dx,ax
  228. ld_loop:
  229.            lodsw                  ; get from si
  230.            shl ax,1
  231.            add ax,cx
  232.            stosw                  ; put in di
  233.            cmp ax,dx              ; check all after first point
  234.            je s ld_exitloop
  235.  
  236.            lodsw                  ; get from si
  237.            shl ax,1
  238.            add ax,cx
  239.            stosw                  ; put in di
  240.            cmp ax,dx              ; check all after first point
  241.            je s ld_exitloop
  242.  
  243.            lodsw                  ; get from si
  244.            shl ax,1
  245.            add ax,cx
  246.            stosw                  ; put in di
  247.            cmp ax,dx              ; check all after first point
  248.            jne s ld_loop
  249.  
  250. ld_exitloop:
  251.            push ebp
  252.            push esi
  253.            push ebx
  254.  
  255.            mov edi,ebp            ; adjust bp into appropriate indexer
  256.  
  257.            movzx ebp,w [edi+2]
  258.            mov cx,[zp+ebp]
  259.            mov bp,dx              ; get point indexers
  260.            add cx,[zp+ebp]        ; take average of two z points for sort
  261.            mov zeds[ebx],cx
  262.  
  263.            mov dx,command
  264.  
  265.            test dx,onscr          ; find if test is for on screen pixels
  266.            jnz test_if_on_screen
  267.            test dl,both+point+line ; check if always visible
  268.            jnz its_line
  269.  
  270. return_screen:
  271.            mov bx,[edi+4]
  272.  
  273.            mov dx,[xp+ebp]        ; first point
  274.            mov ax,[yp+ebp]
  275.            mov esq,ax             ; memory
  276.  
  277.            mov bp,[edi+2]
  278.            mov si,[xp+ebp]        ; second point
  279.            mov ax,[yp+ebp]
  280.            mov dsq,ax             ; memory
  281.  
  282.            mov bp,bx
  283.            mov di,[xp+ebp]        ; third point
  284.            mov bp,[yp+ebp]
  285.  
  286.            call checkfront        ; check if side is visable using p1,2,3
  287.  
  288.            pop ebx
  289.            pop esi                ; return object data pointer
  290.            pop ebp                ; return where we are in sides list
  291.  
  292.            mov dx,command
  293.            or  ecx,ecx
  294.            jle s test_shading     ; cx>-1 if side visible, skip if not
  295.            test dx,double         ; test to use other colour
  296.            jz s skipit            ; miss this side...
  297.            shr texture12,16
  298.            shr colors12,16
  299.            xor w texture12,inverse ; do inverse shading xor dx,256
  300. test_shading:
  301.            test texture12,shade+last
  302.            jnz handle_shading     ; shading bit set, do it...
  303. ln2:
  304.            test dx,check          ; find out if side is only a test side
  305.            jnz s no_show
  306.  
  307.            mov ax,w texture12     ; another side added...
  308.            mov textures[ebx],ax
  309.            mov ax,w colors12
  310.            mov surfcolors[ebx],ax
  311. ln3:
  312.            inc showing            ; another side added...
  313.            add bx,2
  314.            add ebp,maxpolys*2     ; bump ebp to next block
  315. no_show:
  316.            test dx,iterate        ; test dx,512
  317.            jnz handle_surface_iteration
  318. skipit:
  319.            test dx,normal         ; do we skip surface normal data
  320.            jz s no_norml
  321.            add esi,6
  322. no_norml:
  323.            test dx,iterate        ; test dx,512
  324.            jnz failed_iteration   ; skip iteration data if surface failure
  325.  
  326. return_iteration:
  327.            mov edi,ebp            ; set di for next stosw
  328.  
  329.            dec numsides           ; count for next side
  330.            jne ld_lp
  331.  
  332.            mov offsides,edi       ; save for next call
  333.  
  334.            ret
  335.            align 16
  336.  
  337. its_line:
  338.            pop ebx esi ebp
  339.            test w texture12,shade+last
  340.            jz s ln2
  341.  
  342. ; handle gourad/lambert shading
  343.  
  344.            align 16
  345. handle_shading:
  346.            test w texture12,last ; test to use previous colour or bitmap call
  347.            jnz ld_do_previous
  348.  
  349.            if usesteel eq yes
  350.            test w texture12,wavey
  351.            jnz ln2
  352.            endif
  353.  
  354.            push ebx esi ebp dx
  355.  
  356.            cmp lamflag,no         ; is lambert matrix set up?
  357.            je s setitup           ; jump to less likely route
  358. return:
  359.            lodsw                  ; get surface normal
  360.            movsx ebx,ax
  361.            lodsw
  362.            movsx ecx,ax
  363.            lodsw
  364.            movsx ebp,ax
  365.  
  366.            call lrotate           ; rotate surface normal by lambert matrix
  367.  
  368.            pop dx
  369.            test w texture12,inverse ; have the sides flipped? test dx,256
  370.            jnz s invert_colour    ; jump to least likely route
  371. lp_contin:
  372.            add edi,256
  373.            shr di,1               ; result -256 to +256, turn into 0-256
  374.            mov al,b shading_tables[edi] ; now into 0-15
  375.            xor ah,ah
  376.  
  377.            pop ebp esi ebx
  378.  
  379.            add w colors12,ax      ; user can have offset color in object!
  380.  
  381.            jmp ln2
  382.  
  383.            align 16
  384. invert_colour:                    ; inversion occures with other side option,
  385.            neg edi                ; always visible option, and shading option
  386.            jmp lp_contin          ; all combined!
  387.  
  388.            align 16
  389. setitup:
  390.            push esi
  391.            mov esi,currobj        ; this is object # from make1obj
  392.            call lambert           ; set up lambert maxtrix
  393.            mov lamflag,yes
  394.            pop esi
  395.            jmp s return
  396.  
  397.            align 16
  398.  
  399. ld_do_previous:
  400.            mov ax,w colors12
  401.            mov cx,surfcolors[ebx-2]
  402.            and cx,00fh            ; drop old colour block, keep shading indexer
  403.            add cx,ax              ; add new colour block
  404.            mov w colors12,cx
  405.  
  406.            jmp ln2
  407.  
  408. ; handle option 512
  409.  
  410.            align 16
  411.  
  412. handle_surface_iteration:
  413.            test dx,normal
  414.            jz s no_norml2
  415.            add esi,6              ; skip if shading normal present
  416. no_norml2:
  417.            lodsw                  ; get number of extra points in iteration
  418.            mov numpoints,ax       ; set as counter
  419.            mov cx,ax              ; save number of extra points for later use
  420.  
  421.            shl ax,1
  422.            add ax,pointindex      ; pointindex = word indexer to last point
  423.            cmp ax,maxpoints*2     ; test for overflow in points tables
  424.            jae abort_all2
  425.  
  426.            lodsw                  ; get number of sides in iteration
  427.            add numsides,ax
  428.  
  429.            add ax,showing
  430.            cmp ax,maxsurfaces-1   ; check for overflow in "sides" tables
  431.            jae abort_all2
  432.  
  433.            add esi,25*2
  434.  
  435.            or  cx,cx              ; no new points to add? (just surfaces)
  436.            je return_iteration
  437.  
  438.            push ebx ebp dx        ; save load and store locations
  439.  
  440.            mov edi,currobj        ; add more points to xp,yp,zp list
  441.            mov bl,userotate[edi]  ; because iteration is visible
  442.  
  443.            mov di,pointindex      ; movzx edi,pointindex
  444.  
  445.            call middle_load_points
  446.            pop dx ebp ebx
  447.  
  448.            jmp return_iteration
  449.  
  450.            align 16
  451.  
  452. abort_all2:
  453.            add esp,strip_bytes    ; abort from iteration and make1obj
  454.            ret                    ; returning now from makeobjs call
  455.  
  456. ; perform test for option 1024 - generate iteration if points on screen.
  457. ; routine also tests if polygon crosses screen - eg no point is on the screen
  458. ; but the polygon covers the screen, like the front of a very big building.
  459.  
  460.            align 16
  461.  
  462. test_if_on_screen:
  463.            xor bl,bl              ; bl = quadrant flag
  464.            push dx                ; save command
  465.  
  466.            mov esi,ebp
  467. tios:
  468.            mov cx,xp[esi]         ; cx, dx =(x,y) to test
  469.            mov dx,yp[esi]
  470.  
  471.            mov ah,32              ;  32 16  8    determine where point is,
  472.            cmp cx,xmins           ;1  x  x  x    then or bl with location
  473.            jl s ytest             ;2  x  x  x
  474.            mov ah,8               ;4  x  x  x
  475.            cmp cx,xmaxs           ;
  476.            jge s ytest
  477.            mov ah,16
  478. ytest:
  479.            mov al,1
  480.            cmp dx,ymins
  481.            jl s oritall
  482.            mov al,4
  483.            cmp dx,ymaxs
  484.            jge s oritall
  485.  
  486.            cmp ah,16
  487.            je s on_screen         ; a point is on the screen, generate side...
  488. oritall:
  489.            or bl,ah               ; point is not on the screen, but it may
  490.            or bl,al               ; contribute to a polygon which covers the screen.
  491.  
  492.            add edi,2              ; get next connection for another test
  493.            mov si,sides[edi]
  494.            cmp si,bp              ; test if at last connection in iteration test
  495.            jne tios
  496.  
  497.            xor al,al              ; count number of bits in y (must be >2)
  498.            ror bl,1
  499.            adc al,0
  500.            ror bl,1
  501.            adc al,0
  502.            ror bl,1
  503.            adc al,0
  504.            cmp al,1
  505.            jbe s skipit2
  506.  
  507.            xor al,al              ; now count x (must be >2)
  508.            ror bl,1
  509.            adc al,0
  510.            ror bl,1
  511.            adc al,0
  512.            ror bl,1
  513.            adc al,0
  514.            cmp al,1
  515.            jbe s skipit2
  516. on_screen:
  517.            pop dx
  518.  
  519.            test dx,both           ; side is on screen
  520.            jz return_screen       ; test if alway visible
  521.  
  522.            pop ebx esi ebp        ; always, pop and test for shading
  523.            test dx,shade
  524.            jz ln2                 ; no shading - do normal return
  525.            jmp handle_shading
  526.  
  527. skipit2:
  528.            pop dx ebx esi ebp
  529.            jmp skipit
  530.  
  531. ; handle failure of option 512
  532.  
  533.            align 16
  534.  
  535. failed_iteration:
  536.            add esi,4              ; skip # of points and # of surfaces
  537.            xor ecx,ecx
  538.            lodsw                  ; number of bytes to skip in case of failure
  539.            mov cx,ax
  540.            lodsw                  ; get number of points TOTAL in iteration
  541.            shl ax,1               ; in case iteration in iteration in iteration...
  542.            add pointindex,ax
  543.            add esi,ecx
  544.            jmp return_iteration
  545.  
  546.            align 16
  547.  
  548. ; make object esi, routine assumes object is already ON!  note: esi not si!
  549.  
  550. make1obj:
  551.            mov lamflag,no
  552.            mov currobj,esi
  553.  
  554.            shl si,2               ; si = dword
  555.  
  556.            mov ebx,xs[esi]        ; displacement
  557.            sub ebx,eyex
  558.            mov ecx,ys[esi]
  559.            sub ecx,eyey
  560.            mov ebp,zs[esi]
  561.            sub ebp,eyez
  562.  
  563.            shr ebx,8              ; account for decimal places
  564.            test ebx,00800000h
  565.            jz s pm_1
  566.            or ebx, 0ff000000h
  567. pm_1:
  568.            shr ecx,8
  569.            test ecx,00800000h
  570.            jz s pm_2
  571.            or ecx, 0ff000000h
  572. pm_2:
  573.            shr ebp,8
  574.            test ebp,00800000h
  575.            jz s pm_3
  576.            or ebp, 0ff000000h
  577. pm_3:
  578.            cmp ebx,-maxz          ; check if within visible space
  579.            jl s noa2              ; if object miles away, don't bother
  580.            cmp ebx,maxz
  581.            jg s noa2
  582.  
  583.            cmp ebp,-maxz
  584.            jl s noa2
  585.            cmp ebp,maxz
  586.            jg s noa2
  587.  
  588.            cmp ecx,-maxz
  589.            jl s noa2
  590.            cmp ecx,maxz
  591.            jng s mo_misout
  592.  
  593.            align 4
  594. noa2:
  595.            ret
  596.  
  597. mo_misout:
  598.            call zsolve            ; figure out camera displacement
  599.  
  600.            cmp esi,minz           ; check if behind camera, miminum dist.
  601.            jl s noa2
  602.  
  603.            call xsolve
  604.            mov xad,edi            ; store 3d offsets
  605.            call make3dx           ; now make object farther in 3d
  606.  
  607.            cmp edi,xmit           ; tolerance is max object size/ratio
  608.            jl s noa2
  609.            cmp edi,xmat
  610.            jge s noa2
  611.  
  612.            call ysolve            ; solve y and set correct regs
  613.            mov yad,ecx
  614.            call make3dy           ; now make object farther in 3d
  615.  
  616.            cmp ecx,ymit
  617.            jl s noa2
  618.            cmp ecx,ymat
  619.            jge s noa2
  620.  
  621.            mov zad,ebp
  622.            movzx esi,pointindex
  623.  
  624.            mov xp[esi],bx         ; save center of gravity as point 0
  625.            mov yp[esi],cx
  626.            mov zp[esi],bp
  627.  
  628.            mov esi,currobj        ; pop original object number
  629.  
  630.            mov al,userotate[esi]
  631.            test al,himap+point    ; check if bitmap or point
  632.            jnz s mo_special
  633.  
  634.            mov ebx,palxref[esi*4]
  635.            mov palxref,ebx
  636.  
  637.            test al,1+himap+point  ; test to call compound routine
  638.            jnz s mk_skipc         ; skip if anything other than full rotations
  639.            call compound          ; full rotation object, calc. matrix
  640. mk_skipc:
  641.            call loadpoints        ; load points and rotate, exit di=sides
  642.            jmp  loadsides         ; now load sides, starting at di
  643.  
  644.            align 16
  645. noa:
  646.            ret
  647.  
  648.            align 16
  649.  
  650. ; if userotate = 32 then draw bitmap at location x,y,z
  651.  
  652. mo_special:
  653.            cmp pointindex,(maxpoints-1)*2 ; check if there is room in table
  654.            jge s noa
  655.            cmp showing,maxsurfaces-1
  656.            jge s noa
  657.  
  658.            test userotate[esi],point ; is point or bitmap?
  659.            jnz mo_ispoint
  660.  
  661.            cmp ecx,ymit           ; test if bitmap visible
  662.            jl s noa
  663.            cmp ecx,ymat
  664.            jge s noa
  665.  
  666.            cmp ebp,65535          ; far bitmaps screw up, abort
  667.            jge s noa
  668.  
  669.            movzx edi,pointindex
  670.            mov [xp+edi],bx        ; set location of bitmap
  671.            mov [yp+edi],cx
  672.            mov [zp+edi],bp
  673.  
  674.            mov edi,offsides
  675.            add offsides,maxpolys*2 ; update for next object/bitmap
  676.  
  677.            movzx ebx,showing
  678.            shl bp,1               ; adjust so it's the same as loadsides
  679.            mov zeds[ebx*2],bp     ; set z sort indexer
  680.  
  681.            inc showing            ; one more surface...
  682.            xor ah,ah
  683.            mov al,userotate[esi]
  684.            mov textures[ebx*2],ax ; set command for bitmap
  685.  
  686.            mov ax,pointindex
  687.            add pointindex,2
  688.            stosw
  689.            mov ax,whatshape[esi*2]
  690.            stosw
  691.            mov ax,vxs[esi*2]      ; set x and y scales (stretching)
  692.            stosw
  693.            mov ax,vys[esi*2]
  694.            stosw
  695. noa4:
  696.            ret
  697.  
  698.            align 16
  699.  
  700. mo_ispoint:
  701.            cmp bx,xmins            ; draw single point/bullet
  702.            jl s noa4
  703.            cmp bx,xmaxs
  704.            jge s noa4
  705.            cmp cx,ymins
  706.            jl s noa4
  707.            cmp cx,ymaxs            ; ymaxs1 if larger pixel
  708.            jge s noa4
  709.  
  710.            movzx edi,pointindex
  711.            mov [xp+edi],bx         ; set location of point/bitmap
  712.            mov [yp+edi],cx
  713.            mov [zp+edi],bp
  714.  
  715.            mov edi,offsides
  716.            add offsides,maxpolys*2 ; update for next object/bitmap
  717.  
  718.            movzx ebx,showing
  719.            shl bx,1
  720.            mov zeds[ebx],bp       ; set z sort indexer
  721.  
  722.            inc showing            ; one more surface...
  723.  
  724.            mov textures[ebx],64   ; set this command as point
  725.            mov surfcolors[ebx],bulletcolour ; only for variable colours
  726.  
  727.            mov ax,pointindex
  728.            add pointindex,2
  729.  
  730.            stosw
  731.            stosw
  732. noa8:
  733.            ret
  734.  
  735.            align 16
  736.  
  737. set_order:
  738.            movzx ecx,showing
  739.            jcxz s non2_do
  740.            dec ecx
  741.            jz s non2_do
  742.            shl ecx,1
  743.            mov esi,ecx
  744.            add esi,offset order
  745.  
  746.            prc equ 8
  747.  
  748.            cmp cx,prc*2
  749.            jb s ordrloop
  750. bigsloop:
  751.            i=0
  752.            rept prc
  753.            mov [esi+i],cx
  754.            i=i-2
  755.            sub cx,2
  756.            endm
  757.            jz s non2_do
  758.            sub esi,prc*2
  759.            cmp cx,prc*2
  760.            jae s bigsloop
  761. ordrloop:
  762.            mov [esi],cx
  763.            sub esi,2
  764.            dec cx
  765.            loop ordrloop
  766. non2_do:
  767.            mov [order],0           ; fill last
  768.  
  769.            ret
  770.  
  771.            align 16
  772.  
  773. makeobjx:                          ; make all objects, unrolled loop
  774.  
  775.            i=1
  776.  
  777.            rept maxobjects
  778.            local itsoff
  779.  
  780.            test onoff+i,255        ; check on/off
  781.            jz s itsoff
  782.  
  783.            mov esi,i
  784.            call make1obj
  785. itsoff:
  786.  
  787.            i=i+1
  788.            endm
  789.  
  790.            ret                     ; put no code here! make1obj may force abort!
  791.  
  792. ; initialize stuff before beginning 3d animation
  793.  
  794. init_tables:
  795.            mov offsides, offset sides ; clear table indexers for call
  796.            mov pointindex,0
  797.            mov showing,0
  798.            ret
  799.  
  800.            align 16
  801.  
  802. makeobjs:
  803.            call makeobjx          ; make objects
  804.  
  805. flush_surfaces:
  806.            call set_order         ; set ordering of sides
  807.            call sort_list         ; sort sides according to z distance
  808.            call drawvect          ; draw 'em on da screen
  809.  
  810.            mov offsides, offset sides ; clear table indexers for call
  811.            mov pointindex,0
  812.  
  813.            ret
  814.  
  815. code32     ends
  816.            end
  817.